from flask import request, jsonify
from app.models import Like, Favorite, Comment, Video, User, db
from sqlalchemy.exc import IntegrityError
from app.utils.redis_utils import redis_utils
from app.utils.redis_util import RedisKeys, delete_cache_pattern


def like_video():
    """
    点赞视频接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取请求数据
        data = request.get_json()
        
        # 验证参数
        if not data or 'videoId' not in data:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        video_id = data['videoId']
        
        # 验证视频是否存在
        video = Video.query.get(video_id)
        if not video or video.status != 1:
            return jsonify({
                'code': 404,
                'message': '视频不存在或已下架',
                'data': None
            }), 404
        
        # 检查是否已经点赞
        existing_like = Like.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        if existing_like:
            return jsonify({
                'code': 400,
                'message': '您已经点赞过该视频',
                'data': None
            }), 400
        
        # 创建点赞记录
        new_like = Like(user_id=user_id, video_id=video_id)
        db.session.add(new_like)
        
        # 更新视频点赞数
        video.like_count += 1
        
        db.session.commit()
        
        # 清除相关缓存
        # 删除推荐视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET + '*')
        # 删除热门视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET + '*')
        # 删除热门视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET)
        # 删除推荐视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET)
        
        # 返回成功响应
        return jsonify({
            'code': 200,
            'message': '点赞成功',
            'data': {
                'liked': True,
                'likeCount': video.like_count
            }
        })
        
    except IntegrityError:
        db.session.rollback()
        return jsonify({
            'code': 400,
            'message': '您已经点赞过该视频',
            'data': None
        }), 400
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'点赞失败: {str(e)}',
            'data': None
        }), 500


def unlike_video():
    """
    取消点赞接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取请求数据
        data = request.get_json()
        
        # 验证参数
        if not data or 'videoId' not in data:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        video_id = data['videoId']
        
        # 查找点赞记录
        like = Like.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        if not like:
            return jsonify({
                'code': 400,
                'message': '您尚未点赞该视频',
                'data': None
            }), 400
        
        # 更新视频点赞数
        video = Video.query.get(video_id)
        if video and video.like_count > 0:
            video.like_count -= 1
        
        # 删除点赞记录
        db.session.delete(like)
        db.session.commit()
        
        # 清除相关缓存
        # 删除推荐视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET + '*')
        # 删除热门视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET + '*')
        # 删除热门视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET)
        # 删除推荐视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET)
        
        # 返回成功响应
        return jsonify({
            'code': 200,
            'message': '取消点赞成功',
            'data': {
                'liked': False,
                'likeCount': video.like_count if video else 0
            }
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'取消点赞失败: {str(e)}',
            'data': None
        }), 500


def check_like_status():
    """
    检查点赞状态接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取查询参数
        video_id = request.args.get('videoId', type=int)
        
        # 验证参数
        if not video_id:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        # 查询视频
        video = Video.query.get(video_id)
        if not video:
            return jsonify({
                'code': 404,
                'message': '视频不存在',
                'data': None
            }), 404
        
        # 检查是否点赞
        like = Like.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        # 返回状态
        return jsonify({
            'code': 200,
            'message': '获取点赞状态成功',
            'data': {
                'liked': like is not None,
                'likeCount': video.like_count
            }
        })
        
    except Exception as e:
        return jsonify({
            'code': 500,
            'message': f'获取点赞状态失败: {str(e)}',
            'data': None
        }), 500


def get_user_likes():
    """
    获取用户点赞视频ID列表
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取分页参数
        page = request.args.get('page', 1, type=int)
        page_size = request.args.get('pageSize', 10, type=int)
        
        # 查询用户点赞的视频ID
        likes = Like.query.filter_by(user_id=user_id).paginate(
            page=page, per_page=page_size, error_out=False
        )
        
        video_ids = [like.video_id for like in likes.items]
        
        # 返回结果
        return jsonify({
            'code': 200,
            'message': '获取用户点赞视频列表成功',
            'data': {
                'list': video_ids,
                'page': page,
                'pageSize': page_size,
                'total': likes.total,
                'totalPages': likes.pages
            }
        })
        
    except Exception as e:
        return jsonify({
            'code': 500,
            'message': f'获取用户点赞列表失败: {str(e)}',
            'data': None
        }), 500


def favorite_video():
    """
    收藏视频接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取请求数据
        data = request.get_json()
        
        # 验证参数
        if not data or 'videoId' not in data:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        video_id = data['videoId']
        
        # 验证视频是否存在
        video = Video.query.get(video_id)
        if not video or video.status != 1:
            return jsonify({
                'code': 404,
                'message': '视频不存在或已下架',
                'data': None
            }), 404
        
        # 检查是否已经收藏
        existing_favorite = Favorite.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        if existing_favorite:
            return jsonify({
                'code': 400,
                'message': '您已经收藏过该视频',
                'data': None
            }), 400
        
        # 创建收藏记录
        new_favorite = Favorite(user_id=user_id, video_id=video_id)
        db.session.add(new_favorite)
        
        # 更新视频收藏数
        video.collect_count += 1
        
        db.session.commit()
        
        # 清除相关缓存
        # 删除推荐视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET + '*')
        # 删除热门视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET + '*')
        # 删除热门视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET)
        # 删除推荐视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET)
        
        # 返回成功响应
        return jsonify({
            'code': 200,
            'message': '收藏成功',
            'data': {
                'favorited': True,
                'favoriteCount': video.collect_count
            }
        })
        
    except IntegrityError:
        db.session.rollback()
        return jsonify({
            'code': 400,
            'message': '您已经收藏过该视频',
            'data': None
        }), 400
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'收藏失败: {str(e)}',
            'data': None
        }), 500


def unfavorite_video():
    """
    取消收藏接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取请求数据
        data = request.get_json()
        
        # 验证参数
        if not data or 'videoId' not in data:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        video_id = data['videoId']
        
        # 查找收藏记录
        favorite = Favorite.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        if not favorite:
            return jsonify({
                'code': 400,
                'message': '您尚未收藏该视频',
                'data': None
            }), 400
        
        # 更新视频收藏数
        video = Video.query.get(video_id)
        if video and video.collect_count > 0:
            video.collect_count -= 1
        
        # 删除收藏记录
        db.session.delete(favorite)
        db.session.commit()
        
        # 清除相关缓存
        # 删除推荐视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET + '*')
        # 删除热门视频列表缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET + '*')
        # 删除热门视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_HOT_ZSET)
        # 删除推荐视频ZSET缓存
        delete_cache_pattern(RedisKeys.VIDEO_RECOMMENDED_ZSET)
        
        # 返回成功响应
        return jsonify({
            'code': 200,
            'message': '取消收藏成功',
            'data': {
                'favorited': False,
                'favoriteCount': video.collect_count if video else 0
            }
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'取消收藏失败: {str(e)}',
            'data': None
        }), 500


def check_favorite_status():
    """
    检查收藏状态接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取查询参数
        video_id = request.args.get('videoId', type=int)
        
        # 验证参数
        if not video_id:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID',
                'data': None
            }), 400
        
        # 查询视频
        video = Video.query.get(video_id)
        if not video:
            return jsonify({
                'code': 404,
                'message': '视频不存在',
                'data': None
            }), 404
        
        # 检查是否收藏
        favorite = Favorite.query.filter_by(
            user_id=user_id, video_id=video_id
        ).first()
        
        # 返回状态
        return jsonify({
            'code': 200,
            'message': '获取收藏状态成功',
            'data': {
                'favorited': favorite is not None,
                'favoriteCount': video.collect_count
            }
        })
        
    except Exception as e:
        return jsonify({
            'code': 500,
            'message': f'获取收藏状态失败: {str(e)}',
            'data': None
        }), 500


def get_user_favorites():
    """
    获取用户收藏视频ID列表
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取分页参数
        page = request.args.get('page', 1, type=int)
        page_size = request.args.get('pageSize', 10, type=int)
        
        # 查询用户收藏的视频ID
        favorites = Favorite.query.filter_by(user_id=user_id).paginate(
            page=page, per_page=page_size, error_out=False
        )
        
        video_ids = [favorite.video_id for favorite in favorites.items]
        
        # 返回结果
        return jsonify({
            'code': 200,
            'message': '获取用户收藏视频列表成功',
            'data': {
                'list': video_ids,
                'page': page,
                'pageSize': page_size,
                'total': favorites.total,
                'totalPages': favorites.pages
            }
        })
        
    except Exception as e:
        return jsonify({
            'code': 500,
            'message': f'获取用户收藏列表失败: {str(e)}',
            'data': None
        }), 500


def create_comment():
    """
    创建评论接口
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 获取请求数据
        data = request.get_json()
        
        # 验证参数
        if not data or 'videoId' not in data or 'content' not in data:
            return jsonify({
                'code': 400,
                'message': '请提供视频ID和评论内容',
                'data': None
            }), 400
        
        # 获取参数
        video_id = data['videoId']
        content = data['content'].strip()
        parent_id = data.get('parentId')
        
        # 验证视频是否存在
        video = Video.query.get(video_id)
        if not video or video.status != 1:
            return jsonify({
                'code': 404,
                'message': '视频不存在或已下架',
                'data': None
            }), 404
        
        # 验证父评论是否存在
        if parent_id:
            parent_comment = Comment.query.get(parent_id)
            if not parent_comment or parent_comment.video_id != video_id:
                return jsonify({
                    'code': 400,
                    'message': '父评论不存在',
                    'data': None
                }), 400
        
        # 创建评论
        new_comment = Comment(
            content=content,
            user_id=user_id,
            video_id=video_id,
            parent_id=parent_id
        )
        
        db.session.add(new_comment)
        db.session.commit()
        
        # 获取用户信息
        user = User.query.get(user_id)
        
        # 更新视频评论数
        video.comment_count += 1
        db.session.commit()
        
        # 清除视频详情缓存
        try:
            redis_utils.delete(f'video:detail:{video_id}')
        except Exception as cache_error:
            print(f"清除视频详情缓存失败: {str(cache_error)}")
        
        # 返回评论信息
        return jsonify({
            'code': 200,
            'message': '评论成功',
            'data': {
                'id': new_comment.id,
                'content': new_comment.content,
                'likeCount': new_comment.like_count,
                'status': new_comment.status,
                'userId': new_comment.user_id,
                'videoId': new_comment.video_id,
                'parentId': new_comment.parent_id,
                'createdAt': new_comment.created_at.isoformat() + 'Z' if new_comment.created_at else None,
                'updatedAt': new_comment.updated_at.isoformat() + 'Z' if new_comment.updated_at else None,
                'username': user.username if user else None,
                'nickname': user.nickname if user else None,
                'avatar': user.avatar if user else None
            }
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'评论失败: {str(e)}',
            'data': None
        }), 500


def delete_comment(comment_id):
    """
    删除评论接口
    
    Args:
        comment_id: 评论ID
    
    Returns:
        JSON响应
    """
    try:
        # 从请求上下文中获取用户ID
        user_id = request.current_user_id
        
        # 查找评论
        comment = Comment.query.get(comment_id)
        
        if not comment:
            return jsonify({
                'code': 404,
                'message': '评论不存在',
                'data': None
            }), 404
        
        # 检查是否是评论作者
        if comment.user_id != user_id:
            return jsonify({
                'code': 403,
                'message': '删除失败，您无权删除该评论',
                'data': None
            }), 403
        
        # 获取视频ID，用于后续更新评论数和清除缓存
        video_id = comment.video_id
        
        # 删除评论
        db.session.delete(comment)
        db.session.commit()
        
        # 更新视频评论数
        video = Video.query.get(video_id)
        if video and video.comment_count > 0:
            video.comment_count -= 1
            db.session.commit()
        
        # 清除视频详情缓存
        try:
            redis_utils.delete(f'video:detail:{video_id}')
        except Exception as cache_error:
            print(f"清除视频详情缓存失败: {str(cache_error)}")
        
        # 返回成功响应
        return jsonify({
            'code': 200,
            'message': '评论删除成功',
            'data': None
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'code': 500,
            'message': f'删除评论失败: {str(e)}',
            'data': None
        }), 500


def get_video_comments(video_id):
    """
    获取视频评论列表
    
    Args:
        video_id: 视频ID
    
    Returns:
        JSON响应
    """
    try:
        # 验证视频ID
        if not video_id or not video_id.isdigit():
            return jsonify({
                'code': 400,
                'message': '无效的视频ID',
                'data': None
            }), 400
        
        # 获取分页参数
        page = request.args.get('page', 1, type=int)
        page_size = request.args.get('pageSize', 10, type=int)
        
        # 查询评论（只获取一级评论，不包括回复）
        comments = Comment.query.filter_by(
            video_id=int(video_id), parent_id=None, status=1
        ).order_by(Comment.created_at.desc()).paginate(
            page=page, per_page=page_size, error_out=False
        )
        
        total = comments.total
        total_pages = comments.pages
        
        # 格式化评论数据
        comment_list = []
        for comment in comments.items:
            user = User.query.get(comment.user_id)
            comment_list.append({
                'id': comment.id,
                'content': comment.content,
                'likeCount': comment.like_count,
                'status': comment.status,
                'userId': comment.user_id,
                'videoId': comment.video_id,
                'parentId': comment.parent_id,
                'createdAt': comment.created_at.isoformat() + 'Z' if comment.created_at else None,
                'username': user.username if user else None,
                'nickname': user.nickname if user else None,
                'avatar': user.avatar if user else None
            })
        
        # 返回评论列表
        return jsonify({
            'code': 200,
            'message': '获取评论列表成功',
            'data': {
                'list': comment_list,
                'page': page,
                'pageSize': page_size,
                'total': total,
                'totalPages': total_pages
            }
        })
        
    except Exception as e:
        return jsonify({
            'code': 500,
            'message': f'获取评论列表失败: {str(e)}',
            'data': None
        }), 500